package demo1;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.*;

/**
 * 自定义 数据排序
 *  依据快排
 */
public class DataSortUtil {

    /**
     * 用于返回 {order} 字段的值, 如果是 int 类型直接返回, 反之返回 hashcode
     * @param data
     * @param index
     * @param order
     * @return
     */
    private static Object getMethodValue(List data, int index, String order) {
        Object val = "";
        boolean isInteger = false;
        try {
            Field[] fields = data.get(index).getClass().getDeclaredFields();

            for (Field field : fields) {
                if (field.getName().toLowerCase().equals(order.toLowerCase()) && field.getType().toString().contains("Integer")) {
                    isInteger = true;
                    break;
                }
            }

            if (isInteger) {
                val = data.get(index).getClass().getMethod("get".concat(order)).invoke(data.get(index));
            } else {
                val = data.get(index).getClass().getMethod("get".concat(order)).invoke(data.get(index)).hashCode();
            }
        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
            e.printStackTrace();
        }
        return val;
    }

    /**
     * 调用 set 方法
     * @param data
     * @param index
     * @param order
     * @param val
     */
    private static void setMethodValue(List data, int index, String order, Object val) {
        try {
            val = data.get(index).getClass().getMethod("set".concat(order), Object.class).invoke(data.get(index), val);
        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取下标 {index}
     * @param data
     * @param order
     * @param val
     * @return
     */
    private static int getIndex(List data, String order, Object val) {
        int index = 0;
        try {
            for (int i = 0; i < data.size(); i++) {
                if (data.get(i).getClass().getMethod("get".concat(order)).invoke(data.get(i)).equals(val)) {
                    index = i;
                    break;
                }
            }
        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
            e.printStackTrace();
        }
        return index;
    }

    /**
     * 倒序
     * @param list
     * @param left
     * @param right
     * @param order
     */
    public static void QuickSortReverse(List list, Integer left, Integer right, String order) {
        QuickSort(list, left, right, order);
        Collections.reverse(list);
    }

    /**
     * 正序
     * @param data
     * @param left
     * @param right
     * @param order
     */
    public static void QuickSort(List data, Integer left, Integer right, String order) {

        //如果left等于right，即数组只有一个元素，直接返回
        if (left >= right) {
            return;
        }
        //设置最左边的元素为基准值
        int key = (Integer) getMethodValue(data, left, order);
        Object leftKeyValue = data.get(left);
        //数组中比key小的放在左边，比key大的放在右边，key值下标为i
        int i = left;
        int j = right;
        while (i < j) {
            //j向左移，直到遇到比key小的值
            while ((Integer) getMethodValue(data, j, order) >= key && i < j) {
                j--;
            }
            //i向右移，直到遇到比key大的值
            while ((Integer) getMethodValue(data, i, order) <= key && i < j) {
                i++;
            }
            //i和j指向的元素交换
            if (i < j) {
                Object temp = data.get(i);
                data.set(i, data.get(j));
                data.set(j, temp);
            }
        }
        data.set(left, data.get(i));
        data.set(i, leftKeyValue);
        QuickSort(data, left,i-1, order);
        QuickSort(data,i+1, right, order);
    }


}
